home *** CD-ROM | disk | FTP | other *** search
/ ETO Development Tools 1 / ETO Development Tools 1.iso / Essentials / Developer Essentials Jul 90 / Programming / MPW Interfaces & Libraries 3.1 / PInterfaces / AppleTalk.p next >
Encoding:
Text File  |  1989-10-13  |  16.3 KB  |  453 lines  |  [TEXT/MPS ]
  1. {
  2. Created: Tuesday, August 2, 1988 at 5:12 AM
  3.     AppleTalk.p
  4.     Pascal Interface to the Macintosh Libraries
  5.  
  6.     Copyright Apple Computer, Inc. 1985-1988
  7.     All rights reserved.
  8. }
  9.  
  10.  
  11. {$IFC UNDEFINED UsingIncludes}
  12. {$SETC UsingIncludes := 0}
  13. {$ENDC}
  14.  
  15. {$IFC NOT UsingIncludes}
  16.     UNIT AppleTalk;
  17.     INTERFACE
  18. {$ENDC}
  19.  
  20. {$IFC UNDEFINED UsingAppleTalk}
  21. {$SETC UsingAppleTalk := 1}
  22.  
  23. {$I+}
  24. {$SETC AppleTalkIncludes := UsingIncludes}
  25. {$SETC UsingIncludes := 1}
  26. {$IFC UNDEFINED UsingTypes}
  27. {$I $$Shell(PInterfaces)Types.p}
  28. {$ENDC}
  29. {$IFC UNDEFINED UsingOSUtils}
  30. {$I $$Shell(PInterfaces)OSUtils.p}
  31. {$ENDC}
  32. {$SETC UsingIncludes := AppleTalkIncludes}
  33.  
  34. CONST
  35. afpByteRangeLock = 1;                                    {AFPCall command codes}
  36. afpVolClose = 2;                                        {AFPCall command codes}
  37. afpDirClose = 3;                                        {AFPCall command codes}
  38. afpForkClose = 4;                                        {AFPCall command codes}
  39. afpCopyFile = 5;                                        {AFPCall command codes}
  40. afpDirCreate = 6;                                        {AFPCall command codes}
  41. afpFileCreate = 7;                                        {AFPCall command codes}
  42. afpDelete = 8;                                            {AFPCall command codes}
  43. afpEnumerate = 9;                                        {AFPCall command codes}
  44. afpFlush = 10;                                            {AFPCall command codes}
  45. afpForkFlush = 11;                                        {AFPCall command codes}
  46. afpGetDirParms = 12;                                    {AFPCall command codes}
  47. afpGetFileParms = 13;                                    {AFPCall command codes}
  48. afpGetForkParms = 14;                                    {AFPCall command codes}
  49. afpGetSInfo = 15;                                        {AFPCall command codes}
  50. afpGetSParms = 16;                                        {AFPCall command codes}
  51. afpGetVolParms = 17;                                    {AFPCall command codes}
  52. afpLogin = 18;                                            {AFPCall command codes}
  53. afpContLogin = 19;                                        {AFPCall command codes}
  54. afpLogout = 20;                                         {AFPCall command codes}
  55. afpMapID = 21;                                            {AFPCall command codes}
  56. afpMapName = 22;                                        {AFPCall command codes}
  57. afpMove = 23;                                            {AFPCall command codes}
  58. afpOpenVol = 24;                                        {AFPCall command codes}
  59. afpOpenDir = 25;                                        {AFPCall command codes}
  60. afpOpenFork = 26;                                        {AFPCall command codes}
  61. afpRead = 27;                                            {AFPCall command codes}
  62. afpRename = 28;                                         {AFPCall command codes}
  63. afpSetDirParms = 29;                                    {AFPCall command codes}
  64. afpSetFileParms = 30;                                    {AFPCall command codes}
  65. afpSetForkParms = 31;                                    {AFPCall command codes}
  66. afpSetVolParms = 32;                                    {AFPCall command codes}
  67. afpWrite = 33;                                            {AFPCall command codes}
  68. afpGetFlDrParms = 34;                                    {AFPCall command codes}
  69. afpSetFlDrParms = 35;                                    {AFPCall command codes}
  70. afpDTOpen = 48;                                         {AFPCall command codes}
  71. afpDTClose = 49;                                        {AFPCall command codes}
  72. afpGetIcon = 51;                                        {AFPCall command codes}
  73. afpGtIcnInfo = 52;                                        {AFPCall command codes}
  74. afpAddAPPL = 53;                                        {AFPCall command codes}
  75. afpRmvAPPL = 54;                                        {AFPCall command codes}
  76. afpGetAPPL = 55;                                        {AFPCall command codes}
  77. afpAddCmt = 56;                                         {AFPCall command codes}
  78. afpRmvCmt = 57;                                         {AFPCall command codes}
  79. afpGetCmt = 58;                                         {AFPCall command codes}
  80. afpAddIcon = 192;                                        {Special code for ASP Write commands}
  81. xppLoadedBit = 5;                                        { XPP bit in PortBUse }
  82. xppUnitNum = 40;                                        {Unit number for XPP (old ROMs) }
  83. xppRefNum = -41;                                        {.XPP reference number }
  84. scbMemSize = 192;                                        {Size of memory for SCB }
  85. xppFlagClr = 0;                                         {Cs for AFPCommandBlock }
  86. xppFlagSet = 128;                                        {StartEndFlag & NewLineFlag fields. }
  87. lapSize = 20;
  88. ddpSize = 26;
  89. nbpSize = 26;
  90. atpSize = 56;
  91. atpXOvalue = 32;                                        {ATP exactly-once bit }
  92. atpEOMvalue = 16;                                        {ATP End-Of-Message bit }
  93. atpSTSvalue = 8;                                        {ATP Send-Transmission-Status bit }
  94. atpTIDValidvalue = 2;                                    {ATP trans. ID valid bit }
  95. atpSendChkvalue = 1;                                    {ATP send checksum bit }
  96.  
  97.  
  98. TYPE
  99.  
  100. ABCallType = (tLAPRead,tLAPWrite,tDDPRead,tDDPWrite,tNBPLookup,tNBPConfirm,
  101.     tNBPRegister,tATPSndRequest,tATPGetRequest,tATPSdRsp,tATPAddRsp,tATPRequest,
  102.     tATPResponse);
  103.  
  104. ABProtoType = (lapProto,ddpProto,nbpProto,atpProto);
  105.  
  106.  
  107. Str32 = String[32];
  108.  
  109. ABByte = 1..127;
  110.  
  111. LAPAdrBlock = PACKED RECORD
  112.     dstNodeID: Byte;
  113.     srcNodeID: Byte;
  114.     lapProtType: ABByte;
  115.     END;
  116.  
  117. AddrBlock = PACKED RECORD
  118.     aNet: INTEGER;
  119.     aNode: Byte;
  120.     aSocket: Byte;
  121.     END;
  122.  
  123. EntityPtr = ^EntityName;
  124. EntityName = RECORD
  125.     objStr: Str32;
  126.     typeStr: Str32;
  127.     zoneStr: Str32;
  128.     END;
  129.  
  130. { Real definition of EntityName is 3 PACKED strings of any length (32 is just an example). No
  131. offests for Asm since each String address must be calculated by adding length byte to last string ptr.
  132. In Pascal, String(32) will be 34 bytes long since fields never start on an odd byte unless they are 
  133. only a byte long. So this will generate correct looking interfaces for Pascal and C, but they will not
  134. be the same, which is OK since they are not used. }
  135.  
  136. RetransType = PACKED RECORD
  137.     retransInterval: Byte;
  138.     retransCount: Byte;
  139.     END;
  140.  
  141. BDSElement = RECORD
  142.     buffSize: INTEGER;
  143.     buffPtr: Ptr;
  144.     dataSize: INTEGER;
  145.     userBytes: LONGINT;
  146.     END;
  147.  
  148. BDSPtr = ^BDSType;
  149. BDSType = ARRAY [0..7] OF BDSElement;
  150.  
  151. BitMapType = PACKED ARRAY [0..7] OF BOOLEAN;
  152.  
  153. ABRecPtr = ^ABusRecord;
  154. ABRecHandle = ^ABRecPtr;
  155. ABusRecord = RECORD
  156.     abOpcode: ABCallType;
  157.     abResult: INTEGER;
  158.     abUserReference: LONGINT;
  159.     CASE ABProtoType OF
  160.       lapProto:
  161.         (lapAddress: LAPAdrBlock;
  162.         lapReqCount: INTEGER;
  163.         lapActCount: INTEGER;
  164.         lapDataPtr: Ptr);
  165.       ddpProto:
  166.         (ddpType: Byte;
  167.         ddpSocket: Byte;
  168.         ddpAddress: AddrBlock;
  169.         ddpReqCount: INTEGER;
  170.         ddpActCount: INTEGER;
  171.         ddpDataPtr: Ptr;
  172.         ddpNodeID: Byte);
  173.       nbpProto:
  174.         (nbpEntityPtr: EntityPtr;
  175.         nbpBufPtr: Ptr;
  176.         nbpBufSize: INTEGER;
  177.         nbpDataField: INTEGER;
  178.         nbpAddress: AddrBlock;
  179.         nbpRetransmitInfo: RetransType);
  180.       atpProto:
  181.         (atpSocket: Byte;
  182.         atpAddress: AddrBlock;
  183.         atpReqCount: INTEGER;
  184.         atpDataPtr: Ptr;
  185.         atpRspBDSPtr: BDSPtr;
  186.         atpBitmap: BitMapType;
  187.         atpTransID: INTEGER;
  188.         atpActCount: INTEGER;
  189.         atpUserData: LONGINT;
  190.         atpXO: BOOLEAN;
  191.         atpEOM: BOOLEAN;
  192.         atpTimeOut: Byte;
  193.         atpRetries: Byte;
  194.         atpNumBufs: Byte;
  195.         atpNumRsp: Byte;
  196.         atpBDSSize: Byte;
  197.         atpRspUData: LONGINT;
  198.         atpRspBuf: Ptr;
  199.         atpRspSize: INTEGER);
  200.     END;
  201.  
  202. AFPCommandBlock = PACKED RECORD
  203.     cmdByte: Byte;
  204.     startEndFlag: Byte;
  205.     forkRefNum: INTEGER;
  206.     rwOffset: LONGINT;
  207.     reqCount: LONGINT;
  208.     newLineFlag: Byte;
  209.     newLineChar: CHAR;
  210.     END;
  211.  
  212. WDSElement = RECORD
  213.     entryLength: INTEGER;
  214.     entryPtr: Ptr;
  215.     END;
  216.  
  217. NamesTableEntry = RECORD
  218.     qLink: QElemPtr;
  219.     nteAddress: AddrBlock;
  220.     nteData: PACKED ARRAY [1..100] OF CHAR;
  221.     END;
  222.  
  223. MPPParmType = (LAPWriteParm,AttachPHParm,DetachPHParm,OpenSktParm,CloseSktParm,
  224.     WriteDDPParm,OpenATPSktParm,CloseATPSktParm,SendRequestParm,GetRequestParm,
  225.     SendResponseParm,AddResponseParm,RelTCBParm,RelRspCBParm,RegisterNameParm,
  226.     LookupNameParm,ConfirmNameParm,RemoveNameParm,SetSelfSendParm,NSendRequestParm,
  227.     KillSendReqParm,KillGetReqParm,KillNBPParm);
  228.  
  229. MPPPBPtr = ^MPPParamBlock;
  230. MPPParamBlock = PACKED RECORD
  231.     qLink: QElemPtr;                                    {next queue entry}
  232.     qType: INTEGER;                                     {queue type}
  233.     ioTrap: INTEGER;                                    {routine trap}
  234.     ioCmdAddr: Ptr;                                     {routine address}
  235.     ioCompletion: ProcPtr;                                {completion routine}
  236.     ioResult: OSErr;                                    {result code}
  237.     ioNamePtr: StringPtr;                                {->filename}
  238.     ioVRefNum: INTEGER;                                 {volume reference or drive number}
  239.     ioRefNum: INTEGER;                                    {driver reference number}
  240.     csCode: INTEGER;                                    {call command code AUTOMATICALLY set}
  241.     CASE MPPParmType OF
  242.       LAPWriteParm:
  243.         (filler0: INTEGER;
  244.         wdsPointer: Ptr);                                {->Write Data Structure}
  245.       AttachPHParm,DetachPHParm:
  246.         (protType: Byte;                                {ALAP Protocol Type}
  247.         filler1: Byte;
  248.         handler: Ptr);                                    {->protocol handler routine}
  249.       OpenSktParm,CloseSktParm,WriteDDPParm:
  250.         (socket: Byte;                                    {socket number}
  251.         checksumFlag: Byte;                             {checksum flag}
  252.         listener: Ptr);                                 {->socket listener routine}
  253.       RegisterNameParm,LookupNameParm,ConfirmNameParm,RemoveNameParm:
  254.         (interval: Byte;                                {retry interval}
  255.         count: Byte;                                    {retry count}
  256.         entityPtr: Ptr;                                 {->names table element or ->entity name}
  257.         CASE MPPParmType OF
  258.           RegisterNameParm:
  259.             (verifyFlag: Byte;                            {set if verify needed}
  260.             filler3: Byte);
  261.           LookupNameParm:
  262.             (retBuffPtr: Ptr;                            {->return buffer}
  263.             retBuffSize: INTEGER;                        {return buffer size}
  264.             maxToGet: INTEGER;                            {matches to get}
  265.             numGotten: INTEGER);                        {matched gotten}
  266.           ConfirmNameParm:
  267.             (confirmAddr: AddrBlock;                    {->entity}
  268.             newSocket: Byte;                            {socket number}
  269.             filler4: Byte));
  270.       SetSelfSendParm:
  271.         (newSelfFlag: Byte;                             {self-send toggle flag}
  272.         oldSelfFlag: Byte);                             {previous self-send state}
  273.       KillNBPParm:
  274.         (nKillQEl: Ptr);                                {ptr to Q element to cancel}
  275.     END;
  276.  
  277. ATPPBPtr = ^ATPParamBlock;
  278. ATPParamBlock = PACKED RECORD
  279.     qLink: QElemPtr;                                    {next queue entry}
  280.     qType: INTEGER;                                     {queue type}
  281.     ioTrap: INTEGER;                                    {routine trap}
  282.     ioCmdAddr: Ptr;                                     {routine address}
  283.     ioCompletion: ProcPtr;                                {completion routine}
  284.     ioResult: OSErr;                                    {result code}
  285.     userData: LONGINT;                                    {ATP user bytes}
  286.     reqTID: INTEGER;                                    {request transaction ID}
  287.     ioRefNum: INTEGER;                                    {driver reference number}
  288.     csCode: INTEGER;                                    {Call command code automatically set}
  289.     atpSocket: Byte;                                    {currBitMap or socket number}
  290.     atpFlags: Byte;                                     {control information}
  291.     addrBlock: AddrBlock;                                {source/dest. socket address}
  292.     reqLength: INTEGER;                                 {request/response length}
  293.     reqPointer: Ptr;                                    {-> request/response data}
  294.     bdsPointer: Ptr;                                    {-> response BDS}
  295.     CASE MPPParmType OF
  296.       SendRequestParm:
  297.         (numOfBuffs: Byte;                                {number of responses expected}
  298.         timeOutVal: Byte;                                {timeout interval}
  299.         numOfResps: Byte;                                {number of responses actually received}
  300.         retryCount: Byte;                                {number of retries}
  301.         intBuff: INTEGER);                                {used internally for NSendRequest}
  302.       SendResponseParm:
  303.         (filler0: Byte;                                 {numOfBuffs}
  304.         bdsSize: Byte;                                    {number of BDS elements}
  305.         transID: INTEGER);                                {transaction ID}
  306.       GetRequestParm:
  307.         (bitMap: Byte;                                    {bit map}
  308.         filler1: Byte);
  309.       AddResponseParm:
  310.         (rspNum: Byte;                                    {sequence number}
  311.         filler2: Byte);
  312.       KillSendReqParm:
  313.         (aKillQEl: Ptr);                                {ptr to Q element to cancel}
  314.     END;
  315.  
  316. XPPPrmBlkType = (XPPPrmBlk,ASPSizeBlk,ASPAbortPrm);
  317.  
  318. XPPSubPrmType = (ASPOpenPrm,ASPSubPrm);
  319.  
  320. XPPEndPrmType = (AFPLoginPrm,ASPEndPrm);
  321.  
  322. XPPParmBlkPtr = ^XPPParamBlock;
  323. XPPParamBlock = PACKED RECORD
  324.     qLink: QElemPtr;                                    {next queue entry}
  325.     qType: INTEGER;                                     {queue type}
  326.     ioTrap: INTEGER;                                    {routine trap}
  327.     ioCmdAddr: Ptr;                                     {routine address}
  328.     ioCompletion: ProcPtr;                                {completion routine}
  329.     ioResult: OSErr;                                    {result code}
  330.     cmdResult: LONGINT;                                 {command result (ATP user bytes)}
  331.     ioVRefNum: INTEGER;                                 {volume reference or drive number}
  332.     ioRefNum: INTEGER;                                    {driver reference number}
  333.     csCode: INTEGER;                                    {call command code}
  334.     CASE XPPPrmBlkType OF
  335.       ASPAbortPrm:
  336.         (abortSCBPtr: Ptr);                             {SCB pointer for AbortOS}
  337.       ASPSizeBlk:
  338.         (aspMaxCmdSize: INTEGER;                        {for SPGetParms}
  339.         aspQuantumSize: INTEGER;                        {for SPGetParms}
  340.         numSesss: INTEGER);                             {for SPGetParms}
  341.       XPPPrmBlk:
  342.         (sessRefnum: INTEGER;                            {offset to session refnum}
  343.         aspTimeout: Byte;                                {timeout for ATP}
  344.         aspRetry: Byte;                                 {retry count for ATP}
  345.         CASE XPPSubPrmType OF
  346.           ASPOpenPrm:
  347.             (serverAddr: AddrBlock;                     {server address block}
  348.             scbPointer: Ptr;                            {SCB pointer}
  349.             attnRoutine: Ptr);                            {attention routine pointer}
  350.           ASPSubPrm:
  351.             (cbSize: INTEGER;                            {command block size}
  352.             cbPtr: Ptr;                                 {command block pointer}
  353.             rbSize: INTEGER;                            {reply buffer size}
  354.             rbPtr: Ptr;                                 {reply buffer pointer}
  355.             CASE XPPEndPrmType OF
  356.               AFPLoginPrm:
  357.                 (afpAddrBlock: AddrBlock;                {address block in AFP login}
  358.                 afpSCBPtr: Ptr;                         {SCB pointer in AFP login}
  359.                 afpAttnRoutine: Ptr);                    {Attn routine pointer in AFP login}
  360.               ASPEndPrm:
  361.                 (wdSize: INTEGER;                        {write data size}
  362.                 wdPtr: Ptr;                             {write data pointer}
  363.                 ccbStart: ARRAY [0..295] OF Byte)));    {afpWrite max size = 296, else 150}
  364.     END;
  365.  
  366.  
  367.  
  368. FUNCTION OpenXPP(VAR xppRefnum: INTEGER): OSErr;
  369. FUNCTION ASPOpenSession(thePBptr: XPPParmBlkPtr;async: BOOLEAN): OSErr;
  370. FUNCTION ASPCloseSession(thePBptr: XPPParmBlkPtr;async: BOOLEAN): OSErr;
  371. FUNCTION ASPAbortOS(thePBptr: XPPParmBlkPtr;async: BOOLEAN): OSErr;
  372. FUNCTION ASPGetParms(thePBptr: XPPParmBlkPtr;async: BOOLEAN): OSErr;
  373. FUNCTION ASPCloseAll(thePBptr: XPPParmBlkPtr;async: BOOLEAN): OSErr;
  374. FUNCTION ASPUserWrite(thePBptr: XPPParmBlkPtr;async: BOOLEAN): OSErr;
  375. FUNCTION ASPUserCommand(thePBptr: XPPParmBlkPtr;async: BOOLEAN): OSErr;
  376. FUNCTION ASPGetStatus(thePBptr: XPPParmBlkPtr;async: BOOLEAN): OSErr;
  377. FUNCTION AFPCommand(thePBptr: XPPParmBlkPtr;async: BOOLEAN): OSErr;
  378. FUNCTION PAttachPH(thePBptr: MPPPBPtr;async: BOOLEAN): OSErr;
  379. FUNCTION PDetachPH(thePBptr: MPPPBPtr;async: BOOLEAN): OSErr;
  380. FUNCTION PWriteLAP(thePBptr: MPPPBPtr;async: BOOLEAN): OSErr;
  381. FUNCTION POpenSkt(thePBptr: MPPPBPtr;async: BOOLEAN): OSErr;
  382. FUNCTION PCloseSkt(thePBptr: MPPPBPtr;async: BOOLEAN): OSErr;
  383. FUNCTION PWriteDDP(thePBptr: MPPPBPtr;async: BOOLEAN): OSErr;
  384. FUNCTION PRegisterName(thePBptr: MPPPBPtr;async: BOOLEAN): OSErr;
  385. FUNCTION PLookupName(thePBptr: MPPPBPtr;async: BOOLEAN): OSErr;
  386. FUNCTION PConfirmName(thePBptr: MPPPBPtr;async: BOOLEAN): OSErr;
  387. FUNCTION PRemoveName(thePBptr: MPPPBPtr;async: BOOLEAN): OSErr;
  388. FUNCTION PSetSelfSend(thePBptr: MPPPBPtr;async: BOOLEAN): OSErr;
  389. FUNCTION PKillNBP(thePBptr: MPPPBPtr;async: BOOLEAN): OSErr;
  390. FUNCTION POpenATPSkt(thePBptr: ATPPBPtr;async: BOOLEAN): OSErr;
  391. FUNCTION PCloseATPSkt(thePBPtr: ATPPBPtr;async: BOOLEAN): OSErr;
  392. FUNCTION PSendRequest(thePBPtr: ATPPBPtr;async: BOOLEAN): OSErr;
  393. FUNCTION PGetRequest(thePBPtr: ATPPBPtr;async: BOOLEAN): OSErr;
  394. FUNCTION PSendResponse(thePBPtr: ATPPBPtr;async: BOOLEAN): OSErr;
  395. FUNCTION PAddResponse(thePBPtr: ATPPBPtr;async: BOOLEAN): OSErr;
  396. FUNCTION PRelTCB(thePBPtr: ATPPBPtr;async: BOOLEAN): OSErr;
  397. FUNCTION PRelRspCB(thePBPtr: ATPPBPtr;async: BOOLEAN): OSErr;
  398. FUNCTION PNSendRequest(thePBPtr: ATPPBPtr;async: BOOLEAN): OSErr;
  399. FUNCTION PKillSendReq(thePBPtr: ATPPBPtr;async: BOOLEAN): OSErr;
  400. FUNCTION PKillGetReq(thePBPtr: ATPPBPtr;async: BOOLEAN): OSErr;
  401. PROCEDURE BuildLAPwds(wdsPtr: Ptr;dataPtr: Ptr;destHost: INTEGER;prototype: INTEGER;
  402.     frameLen: INTEGER);
  403. PROCEDURE BuildDDPwds(wdsPtr: Ptr;headerPtr: Ptr;dataPtr: Ptr;netAddr: AddrBlock;
  404.     ddpType: INTEGER;dataLen: INTEGER);
  405. PROCEDURE NBPSetEntity(buffer: Ptr;nbpObject: Str32;nbpType: Str32;nbpZone: Str32);
  406. PROCEDURE NBPSetNTE(ntePtr: Ptr;nbpObject: Str32;nbpType: Str32;nbpZone: Str32;
  407.     socket: INTEGER);
  408. FUNCTION GetBridgeAddress: INTEGER;
  409. FUNCTION BuildBDS(buffPtr: Ptr;bdsPtr: Ptr;buffSize: INTEGER): INTEGER;
  410. FUNCTION MPPOpen: OSErr;
  411. FUNCTION MPPClose: OSErr;
  412. FUNCTION LAPOpenProtocol(theLAPType: ABByte;protoPtr: Ptr): OSErr;
  413. FUNCTION LAPCloseProtocol(theLAPType: ABByte): OSErr;
  414. FUNCTION LAPWrite(abRecord: ABRecHandle;async: BOOLEAN): OSErr;
  415. FUNCTION LAPRead(abRecord: ABRecHandle;async: BOOLEAN): OSErr;
  416. FUNCTION LAPRdCancel(abRecord: ABRecHandle): OSErr;
  417. FUNCTION DDPOpenSocket(VAR theSocket: Byte;sktListener: Ptr): OSErr;
  418. FUNCTION DDPCloseSocket(theSocket: Byte): OSErr;
  419. FUNCTION DDPRead(abRecord: ABRecHandle;retCksumErrs: BOOLEAN;async: BOOLEAN): OSErr;
  420. FUNCTION DDPWrite(abRecord: ABRecHandle;doChecksum: BOOLEAN;async: BOOLEAN): OSErr;
  421. FUNCTION DDPRdCancel(abRecord: ABRecHandle): OSErr;
  422. FUNCTION ATPLoad: OSErr;
  423. FUNCTION ATPUnload: OSErr;
  424. FUNCTION ATPOpenSocket(addrRcvd: AddrBlock;VAR atpSocket: Byte): OSErr;
  425. FUNCTION ATPCloseSocket(atpSocket: Byte): OSErr;
  426. FUNCTION ATPSndRequest(abRecord: ABRecHandle;async: BOOLEAN): OSErr;
  427. FUNCTION ATPRequest(abRecord: ABRecHandle;async: BOOLEAN): OSErr;
  428. FUNCTION ATPReqCancel(abRecord: ABRecHandle;async: BOOLEAN): OSErr;
  429. FUNCTION ATPGetRequest(abRecord: ABRecHandle;async: BOOLEAN): OSErr;
  430. FUNCTION ATPSndRsp(abRecord: ABRecHandle;async: BOOLEAN): OSErr;
  431. FUNCTION ATPAddRsp(abRecord: ABRecHandle): OSErr;
  432. FUNCTION ATPResponse(abRecord: ABRecHandle;async: BOOLEAN): OSErr;
  433. FUNCTION ATPRspCancel(abRecord: ABRecHandle;async: BOOLEAN): OSErr;
  434. FUNCTION NBPRegister(abRecord: ABRecHandle;async: BOOLEAN): OSErr;
  435. FUNCTION NBPLookup(abRecord: ABRecHandle;async: BOOLEAN): OSErr;
  436. FUNCTION NBPExtract(theBuffer: Ptr;numInBuf: INTEGER;whichOne: INTEGER;
  437.     VAR abEntity: EntityName;VAR address: AddrBlock): OSErr;
  438. FUNCTION NBPConfirm(abRecord: ABRecHandle;async: BOOLEAN): OSErr;
  439. FUNCTION NBPRemove(abEntity: EntityPtr): OSErr;
  440. FUNCTION NBPLoad: OSErr;
  441. FUNCTION NBPUnload: OSErr;
  442. PROCEDURE RemoveHdlBlocks;
  443. FUNCTION GetNodeAddress(VAR myNode: INTEGER;VAR myNet: INTEGER): OSErr;
  444. FUNCTION IsMPPOpen: BOOLEAN;
  445. FUNCTION IsATPOpen: BOOLEAN;
  446.  
  447. {$ENDC}    { UsingAppleTalk }
  448.  
  449. {$IFC NOT UsingIncludes}
  450.     END.
  451. {$ENDC}
  452.  
  453.